package com.example.service;

import com.bob.auth.dto.request.EmployeeInsertRequest;
import com.example.config.SftpConfig;
import com.example.parser.DatFileParser;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.io.InputStream;
import java.util.List;

/**
 * 简化版远程数据导入服务
 * 直接解析入库，不返回复杂结果
 */
@Slf4j
@Service
public class SimpleRemoteImportService {
    
    @Resource
    private SftpService sftpService;
    
    @Resource
    private SftpConfig sftpConfig;
    
    @Resource
    private DatFileParser datFileParser;
    
    @Resource
    private EmployeeService employeeService;
    
    /**
     * 从远程服务器流式导入当天的员工数据
     * 只导入文件名中日期为当天的EMPLOYEE文件
     * 直接解析并入库，不返回详细结果
     */
    public void importEmployeesFromRemote() {
        log.info("========== 开始从远程服务器导入当天员工数据 ==========");
        
        try {
            // 1. 连接SFTP
            log.info("步骤1：连接SFTP服务器");
            sftpService.connect();
            
            // 2. 列出当天的员工文件
            log.info("步骤2：列出当天的员工数据文件");
            List<String> todayFiles = sftpService.listTodayEmployeeFiles(sftpConfig.getRemoteDir());
            
            if (todayFiles.isEmpty()) {
                log.warn("⚠️ 未找到当天的员工数据文件，跳过导入");
                return;
            }
            
            log.info("找到 {} 个当天员工文件，开始处理", todayFiles.size());
            
            // 3. 逐个处理文件
            int totalFiles = 0;
            int totalRecords = 0;
            
            for (String fileName : todayFiles) {
                try {
                    log.info("========== 处理当天文件：{} ==========", fileName);
                    
                    // 构建远程文件路径
                    String remoteFilePath = sftpConfig.getRemoteDir() + "/" + fileName;
                    
                    // 获取文件流
                    InputStream inputStream = sftpService.getFileInputStream(remoteFilePath);
                    
                    // 解析数据
                    List<EmployeeInsertRequest> employees = 
                        datFileParser.parseEmployeeStream(inputStream, fileName);
                    
                    log.info("文件 {} 解析完成，共 {} 条记录", fileName, employees.size());
                    
                    // 直接批量入库
                    if (!employees.isEmpty()) {
                        employeeService.batchInsertSimple(employees);
                        log.info("✅ 文件 {} 入库完成，成功 {} 条", fileName, employees.size());
                        totalRecords += employees.size();
                    } else {
                        log.warn("文件 {} 没有有效数据", fileName);
                    }
                    
                    totalFiles++;
                    
                } catch (Exception e) {
                    log.error("❌ 处理文件 {} 失败：{}", fileName, e.getMessage(), e);
                    // 继续处理下一个文件
                }
            }
            
            log.info("========== 当天员工数据导入完成 ==========");
            log.info("✅ 处理文件数：{}", totalFiles);
            log.info("✅ 导入记录数：{}", totalRecords);
            
        } catch (Exception e) {
            log.error("远程数据导入失败", e);
            throw new RuntimeException("导入失败：" + e.getMessage(), e);
        } finally {
            // 4. 断开连接
            log.info("断开SFTP连接");
            sftpService.disconnect();
        }
    }
    
    /**
     * 导入匹配模式的文件
     * 
     * @param filePattern 文件名模式（如：*.dat）
     */
    public void importEmployeesByPattern(String filePattern) {
        log.info("========== 开始导入员工数据（模式：{}） ==========", filePattern);
        
        try {
            sftpService.connect();
            
            // 列出并筛选文件
            List<String> allFiles = sftpService.listFiles(sftpConfig.getRemoteDir());
            String regex = filePattern.replace(".", "\\.").replace("*", ".*");
            
            int totalRecords = 0;
            for (String fileName : allFiles) {
                if (fileName.matches(regex)) {
                    log.info("处理匹配文件：{}", fileName);
                    
                    String remoteFilePath = sftpConfig.getRemoteDir() + "/" + fileName;
                    InputStream inputStream = sftpService.getFileInputStream(remoteFilePath);
                    
                    List<EmployeeInsertRequest> employees = 
                        datFileParser.parseEmployeeStream(inputStream, fileName);
                    
                    if (!employees.isEmpty()) {
                        employeeService.batchInsertSimple(employees);
                        totalRecords += employees.size();
                        log.info("文件 {} 入库完成，{} 条记录", fileName, employees.size());
                    }
                }
            }
            
            log.info("========== 导入完成，共 {} 条记录 ==========", totalRecords);
            
        } catch (Exception e) {
            log.error("导入失败", e);
            throw new RuntimeException("导入失败：" + e.getMessage(), e);
        } finally {
            sftpService.disconnect();
        }
    }
    
    /**
     * 导入单个文件
     * 
     * @param fileName 文件名（不含路径）
     */
    public void importSingleFile(String fileName) {
        log.info("========== 开始导入文件：{} ==========", fileName);
        
        try {
            sftpService.connect();
            
            String remoteFilePath = sftpConfig.getRemoteDir() + "/" + fileName;
            
            // 检查文件是否存在
            if (!sftpService.fileExists(remoteFilePath)) {
                throw new RuntimeException("文件不存在：" + fileName);
            }
            
            // 获取文件流并解析
            InputStream inputStream = sftpService.getFileInputStream(remoteFilePath);
            List<EmployeeInsertRequest> employees = 
                datFileParser.parseEmployeeStream(inputStream, fileName);
            
            // 直接入库
            if (!employees.isEmpty()) {
                employeeService.batchInsertSimple(employees);
                log.info("========== 导入完成，共 {} 条记录 ==========", employees.size());
            } else {
                log.warn("文件中没有有效数据");
            }
            
        } catch (Exception e) {
            log.error("导入失败", e);
            throw new RuntimeException("导入失败：" + e.getMessage(), e);
        } finally {
            sftpService.disconnect();
        }
    }
    
    /**
     * 测试SFTP连接
     */
    public boolean testConnection() {
        try {
            log.info("========== 测试SFTP连接 ==========");
            sftpService.connect();
            
            // 验证连接状态
            boolean connected = sftpService.isConnected();
            String status = sftpService.getConnectionStatus();
            
            log.info("连接测试结果：{}", connected ? "✅ 成功" : "❌ 失败");
            log.info("连接状态详情：{}", status);
            
            sftpService.disconnect();
            return connected;
        } catch (Exception e) {
            log.error("❌ 连接失败：{}", e.getMessage(), e);
            return false;
        }
    }
    
    /**
     * 获取SFTP连接状态详情
     */
    public String getConnectionStatus() {
        try {
            sftpService.connect();
            String status = sftpService.getConnectionStatus();
            sftpService.disconnect();
            return status;
        } catch (Exception e) {
            return "SFTP连接失败：" + e.getMessage();
        }
    }
    
    /**
     * 列出远程所有文件
     */
    public List<String> listRemoteFiles() {
        try {
            sftpService.connect();
            List<String> files = sftpService.listFiles(sftpConfig.getRemoteDir());
            sftpService.disconnect();
            return files;
        } catch (Exception e) {
            log.error("列出文件失败", e);
            throw new RuntimeException("列出文件失败：" + e.getMessage(), e);
        }
    }
    
    /**
     * 列出当天的员工数据文件
     */
    public List<String> listTodayEmployeeFiles() {
        try {
            sftpService.connect();
            List<String> files = sftpService.listTodayEmployeeFiles(sftpConfig.getRemoteDir());
            sftpService.disconnect();
            return files;
        } catch (Exception e) {
            log.error("列出当天员工文件失败", e);
            throw new RuntimeException("列出当天员工文件失败：" + e.getMessage(), e);
        }
    }
}
